package com.smartcruise.data.cruiseData;

import android.text.TextUtils;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.TypeReference;
import com.smartcruise.util.FileUtils;
import com.smartcruise.util.Key;
import com.smartcruise.util.ListUtils;
import com.smartcruise.util.network.OssManager;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import io.realm.RealmObject;

//节点任务
public class NodeTaskListBean extends RealmObject {
    /**
     * nodeId : 5a6ed45860a8cd2f54b0c514
     * patrollingNodeEntity : {"coordinate":"[{\"lng\":118.48734229803085,\"lat\":32.07332237159644}]","coordinateList":[{"lat":"32.07332237159644","lng":"118.48734229803085"}],"id":"5a6ed45860a8cd2f54b0c514","mapId":"5a6ecbe760a8cd05a4c0fb7a","name":"节点2","type":"marker"}
     * taskList : ["文字"]
     */

    private String nodeId;//巡护节点id
    private PatrollingNodeEntityBean patrollingNodeEntity;//巡护节点
    private String taskList;  //任务需要完成的操作 比如需要拍照
    private String taskResultMap;//巡航任务的结果  格式为Map<String,List<String>> key为任务名称 value为结果  例如{“文字”:[“这还挺有意思”],”拍照”:[“uuid#照片1的缩略图字符串#图片1在对象存储服务器上的地址”,”uuid#照片2的缩略图字符串#图片2在对象存储服务器上的地址”,”uuid#照片3的缩略图字符串#图片3在对象存储服务器上的地址”],”摄像”:[“uuid#视频第一帧的缩略图字符串#视频在对象存储服务器上的地址”]}

    /**
     * *********************************本地属性******************************************************
     */
    private String originalImages;//本地图片
    private String originalVideos;//本地视频
    private String originalAudios;//本地语音
    private int uploadStatus;//0未上传 1部分上传 2全部上传

    public String getNodeId() {
        return nodeId;
    }

    public void setNodeId(String nodeId) {
        this.nodeId = nodeId;
    }

    public PatrollingNodeEntityBean getPatrollingNodeEntity() {
        return patrollingNodeEntity;
    }

    public void setPatrollingNodeEntity(PatrollingNodeEntityBean patrollingNodeEntity) {
        this.patrollingNodeEntity = patrollingNodeEntity;
    }

    public String getTaskList() {
        return taskList;
    }

    public void setTaskList(String taskList) {
        this.taskList = taskList;
    }

    public String getTaskResultMap() {
        return taskResultMap;
    }

    public void setTaskResultMap(String taskResultMap) {
        this.taskResultMap = taskResultMap;
    }

    public int getUploadStatus() {
        return uploadStatus;
    }

    public void setUploadStatus(int uploadStatus) {
        this.uploadStatus = uploadStatus;
    }

    /**
     * ******************************************便捷方法******************************************************
     */

    /**
     * description:判断该节点是否需要记录文字
     */

    public boolean isNeedText() {
        return taskList != null && taskList.contains(CruiseContract.NODE_EDIT_DATA_TEXT);
    }

    /**
     * description:判断该节点是否需要扫描二维码
     */

    public boolean isNeedScan() {
        return taskList != null && taskList.contains(CruiseContract.NODE_EDIT_DATA_SCAN);
    }

    /**
     * description:判断该节点是否需要拍摄照片
     */

    public boolean isNeedPicture() {
        return taskList != null && taskList.contains(CruiseContract.NODE_EDIT_DATA_PICTURE);
    }

    /**
     * description:判断该节点是否需要拍摄视频
     */

    public boolean isNeedVideo() {
        return taskList != null && taskList.contains(CruiseContract.NODE_EDIT_DATA_VIDEO);
    }

    /**
     * description:判断该节点是否需要录音
     */

    public boolean isNeedAudio() {
        return taskList != null && taskList.contains(CruiseContract.NODE_EDIT_DATA_AUDIO);
    }

    /**
     * description:判断该节点当前是否已经记录了文字
     */

    public boolean isHaveText() {
        return !TextUtils.isEmpty(getText());
    }

    /**
     * description:判断该节点是否已经扫描了二维码
     */

    public boolean isHaveQrCode() {
        return !TextUtils.isEmpty(getQrCode());
    }

    /**
     * description:将任务执行结果的字符串转换为Map
     */

    private Map<String, String> getResultMap() {
        if (TextUtils.isEmpty(taskResultMap)) {
            return null;
        }
        return JSON.parseObject(taskResultMap, new TypeReference<Map<String, String>>() {
        });
    }

    /**
     * description:设置文字信息
     */

    public void setText(String text) {
        setSpecialResultData(CruiseContract.NODE_EDIT_DATA_TEXT, Collections.singletonList(text));
    }

    /**
     * description:获取记录的文字信息
     */

    public String getText() {
        if (getResultMap() != null) {
            String text = getResultMap().get(CruiseContract.NODE_EDIT_DATA_TEXT);
            if (text != null) {
                String[] strings = JSON.parseObject(text, String[].class);
                if (strings != null && strings.length > 0) {
                    return strings[0];
                }
            }
        }
        return null;
    }

    /**
     * description:设置二维码信息
     */

    public void setQrCode(String text) {
        setSpecialResultData(CruiseContract.NODE_EDIT_DATA_SCAN, Collections.singletonList(text));
    }

    /**
     * description:获取记录的二维码信息
     */

    public String getQrCode() {
        if (getResultMap() != null) {
            String text = getResultMap().get(CruiseContract.NODE_EDIT_DATA_SCAN);
            if (text != null) {
                String[] strings = JSON.parseObject(text, String[].class);
                if (strings != null && strings.length > 0) {
                    return strings[0];
                }
            }
        }
        return null;
    }

    /**
     * description:设置本地源图片路径
     */

    public void setOriginalImage(List<String> images) {
        StringBuilder stringBuilder = new StringBuilder();
        if (ListUtils.isHaveContent(images)) {
            for (String image : images) {
                stringBuilder.append(image).append("#");
            }
        }
        originalImages = stringBuilder.toString();
    }

    /**
     * description:获取存储的本地源图片路径
     */

    public List<String> getOriginalImage() {
        if (TextUtils.isEmpty(originalImages)) {
            return null;
        } else {
            return Arrays.asList(originalImages.split(Key.SPLIT));
        }
    }

    /**
     * description:获取已经上传的缩略图url
     */

    public List<String> getThumbnailImage() {
        return getSpecialPositionList(CruiseContract.NODE_EDIT_DATA_PICTURE, 2);
    }

    /**
     * description:获取已经上传的原图url
     */

    public List<String> getNetImage() {
        return getSpecialPositionList(CruiseContract.NODE_EDIT_DATA_PICTURE, 3);
    }

    /**
     * description:设置本地源视频文件路径
     */

    public void setOriginalVideos(List<String> videos) {
        StringBuilder stringBuilder = new StringBuilder();
        if (ListUtils.isHaveContent(videos)) {
            for (String image : videos) {
                stringBuilder.append(image).append("#");
            }
        }
        originalVideos = stringBuilder.toString();
    }

    /**
     * description:获取存储的本地源视频路径
     */

    public List<String> getOriginalVideos() {
        if (TextUtils.isEmpty(originalVideos)) {
            return null;
        } else {
            return Arrays.asList(originalVideos.split("#"));
        }
    }

    /**
     * description:获取已上传的视频缩略图url
     */

    public List<String> getThumbnailVideo() {
        return getSpecialPositionList(CruiseContract.NODE_EDIT_DATA_VIDEO, 2);
    }

    /**
     * description:获取已上传的视频源文件url
     */

    public List<String> getNetVideo() {
        return getSpecialPositionList(CruiseContract.NODE_EDIT_DATA_VIDEO, 3);
    }

    /**
     * description:设置本地源语音的文件路径
     */

    public void setOriginalAudios(List<String> audios) {
        StringBuilder stringBuilder = new StringBuilder();
        if (audios != null && !audios.isEmpty()) {
            for (String image : audios) {
                stringBuilder.append(image).append("#");
            }
        }
        originalAudios = stringBuilder.toString();
    }

    /**
     * description:获取存储的本地源语音的路径
     */

    public List<String> getOriginalAudios() {
        if (TextUtils.isEmpty(originalAudios)) {
            return null;
        } else {
            return Arrays.asList(originalAudios.split("#"));
        }
    }

    /**
     * description:获取已上传的语音url
     */

    public List<String> getNetAudio() {
        return getSpecialPositionList(CruiseContract.NODE_EDIT_DATA_AUDIO, 2);
    }

    /**
     * description:获取指定类型的文件在指定位置的数据列表
     */

    private List<String> getSpecialPositionList(String type, int position) {
        try {
            if (getResultMap() != null) {
                String text = getResultMap().get(type);
                List<String> resultList = new ArrayList<>();
                if (text != null) {
                    String[] strings = JSON.parseObject(text, String[].class);
                    if (strings != null && strings.length > 0) {
                        for (String string : strings) {
                            String[] details = string.split(Key.SPLIT);
                            if (details.length >= position) {
                                resultList.add(details[position - 1]);
                            }
                        }
                    }
                    return resultList;
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * description:获取可展示的图片
     * 1.如果是本地任务 显示本地图片
     * 2.如果是已上传的任务:
     * (1)如果审核通过 显示网络图片
     * (2)其余的同时显示网络图片和本地图片
     */

    public List<String> getShowImage(CruiseData cruiseData) {
        if (!cruiseData.isFromNet()) {//本地数据 显示本地图片
            return getOriginalImage();
        } else {
            if (cruiseData.isAuditSuccess()) {
                return getThumbnailImage();
            } else {
                ArrayList<String> arrayList = new ArrayList<>();
                if (ListUtils.isHaveContent(getOriginalImage())) {
                    arrayList.addAll(getOriginalImage());
                }
                if (ListUtils.isHaveContent(getThumbnailImage())) {
                    arrayList.addAll(getThumbnailImage());
                }
                return arrayList;
            }
        }
    }

    /**
     * description:获取可展示的视频
     * 1.如果是本地任务 显示本地视频
     * 2.如果是已上传的任务:
     * (1)如果审核通过 显示网络视频
     * (2)其余的同时显示网络视频和本地视频
     */
    public List<String> getShowVideo(CruiseData cruiseData) {
        if (!cruiseData.isFromNet()) {//本地数据 获取本地视频
            return getOriginalVideos();
        } else {
            if (cruiseData.isAuditSuccess()) {
                return getNetVideo();
            } else {
                ArrayList<String> arrayList = new ArrayList<>();
                if (ListUtils.isHaveContent(getOriginalVideos())) {
                    arrayList.addAll(getOriginalVideos());
                }
                if (ListUtils.isHaveContent(getNetVideo())) {
                    arrayList.addAll(getNetVideo());
                }
                return arrayList;
            }
        }
    }

    /**
     * description:获取可展示的语音
     * 1.如果是本地任务 显示本地语音
     * 2.如果是已上传的任务:
     * (1)如果审核通过 显示网络语音
     * (2)其余的同时显示网络语音和本地语音
     */
    public List<String> getShowAudio(CruiseData cruiseData) {
        if (!cruiseData.isFromNet()) {//本地数据 获取本地语音
            return getOriginalAudios();
        } else {
            if (cruiseData.isAuditSuccess()) {
                return getNetAudio();
            } else {
                ArrayList<String> arrayList = new ArrayList<>();
                if (ListUtils.isHaveContent(getOriginalAudios())) {
                    arrayList.addAll(getOriginalAudios());
                }
                if (ListUtils.isHaveContent(getNetAudio())) {
                    arrayList.addAll(getNetAudio());
                }
                return arrayList;
            }
        }
    }

    /**
     * description:获取已经上传的图片 格式没有转化 格式为uuid#缩略图url#原图url
     */

    private List<String> getUploadedImage() {
        if (getResultMap() != null) {
            String text = getResultMap().get(CruiseContract.NODE_EDIT_DATA_PICTURE);
            if (text != null) {
                String[] strings = JSON.parseObject(text, String[].class);
                List<String> list = new ArrayList<>();
                for (String string : strings) {
                    if (!TextUtils.isEmpty(string)) {
                        list.add(string);
                    }
                }
                return list;
            }
        }
        return null;
    }

    /**
     * description:获取已经上传的视频 格式没有转化
     */

    private List<String> getUploadedVideo() {
        if (getResultMap() != null) {
            String text = getResultMap().get(CruiseContract.NODE_EDIT_DATA_VIDEO);
            if (text != null) {
                String[] strings = JSON.parseObject(text, String[].class);
                List<String> list = new ArrayList<>();
                for (String string : strings) {
                    if (!TextUtils.isEmpty(string)) {
                        list.add(string);
                    }
                }
                return list;
            }
        }
        return null;
    }

    /**
     * description:获取已经上传的音频 格式没有转化
     */

    private List<String> getUploadedAudio() {
        if (getResultMap() != null) {
            String text = getResultMap().get(CruiseContract.NODE_EDIT_DATA_AUDIO);
            if (text != null) {
                String[] strings = JSON.parseObject(text, String[].class);
                List<String> list = new ArrayList<>();
                for (String string : strings) {
                    if (!TextUtils.isEmpty(string)) {
                        list.add(string);
                    }
                }
                return list;
            }
        }
        return null;
    }

    /**
     * description:更新已经上传的图片
     */

    public void refreshUploadedImage(List<String> savedImages) {
        if (ListUtils.isHaveContent(savedImages) && ListUtils.isHaveContent(getUploadedImage())) {
            //找出仍然需要保存的数据 剔除不需要保存的数据
            ArrayList<String> needSaveData = new ArrayList<>();
            for (String s : getUploadedImage()) {
                for (String savedImage : savedImages) {
                    if (s.contains(savedImage) && !needSaveData.contains(s)) {
                        needSaveData.add(s);
                    }
                }
            }
            setSpecialResultData(CruiseContract.NODE_EDIT_DATA_PICTURE, needSaveData);
        } else {//没有数据需要保存 保存空数据
            setSpecialResultData(CruiseContract.NODE_EDIT_DATA_PICTURE, Collections.singletonList(""));
        }
    }


    /**
     * description:更新已经上传的视频
     */

    public void refreshUploadedVideo(List<String> savedVideos) {
        if (ListUtils.isHaveContent(savedVideos) && getUploadedVideo() != null) {
            //找出仍然需要保存的数据 剔除不需要保存的数据
            ArrayList<String> needSaveData = new ArrayList<>();
            for (String s : getUploadedVideo()) {
                for (String savedVideo : savedVideos) {
                    if (s.contains(savedVideo) && !needSaveData.contains(s)) {
                        needSaveData.add(s);
                    }
                }
            }
            setSpecialResultData(CruiseContract.NODE_EDIT_DATA_VIDEO, needSaveData);
        } else {//没有数据需要保存 保存空数据
            setSpecialResultData(CruiseContract.NODE_EDIT_DATA_VIDEO, Collections.singletonList(""));
        }
    }


    /**
     * description:更新已经上传的音频
     */

    public void refreshUploadedAudio(List<String> savedAudios) {
        if (ListUtils.isHaveContent(savedAudios) && getUploadedAudio() != null) {
            //找出仍然需要保存的数据 剔除不需要保存的数据
            ArrayList<String> needSaveData = new ArrayList<>();
            for (String s : getUploadedAudio()) {
                for (String savedAudio : savedAudios) {
                    if (s.contains(savedAudio) && !needSaveData.contains(s)) {
                        needSaveData.add(s);
                    }
                }
            }
            setSpecialResultData(CruiseContract.NODE_EDIT_DATA_AUDIO, needSaveData);
        } else {//没有数据需要保存 保存空数据
            setSpecialResultData(CruiseContract.NODE_EDIT_DATA_AUDIO, Collections.singletonList(""));
        }
    }

    /**
     * description:将文字信息添加到节点任务结果中
     * 如果没有文字信息 也要按格式保存空字符串
     */

    public void buildText() {
        if (TextUtils.isEmpty(getText())) {
            setText("");
        }
    }

    /**
     * description:将二维码信息添加到节点任务结果中
     * 如果没有二维码信息 也要按格式保存空字符串
     */

    public void buildQrCode() {
        if (TextUtils.isEmpty(getQrCode())) {
            setQrCode("");
        }
    }

    /**
     * description:将图片信息添加到任务结果中 从服务器下载的任务需要考虑保留已经上传的图片
     * 1.如果是本地任务 则直接将已上传的图片清空 重新构造
     * 2.如果是从服务器下载的任务 则：
     * (1).保留已经上传的图片
     * (2).添加本地图片
     *
     * @param all 标记是否需要添加原图路径
     */

    public void buildImages(boolean all, CruiseData cruiseData) {//图片格式为 uuid#压缩图片路径#原图路径
        List<String> stringList = getUploadedImage();
        if (stringList == null) {
            stringList = new ArrayList<>();
        }
        if (cruiseData.isFromNet()) {
            if (ListUtils.isHaveContent(getOriginalImage())) {//有数据的话保存
                //剔除掉那些已经存的内容 避免重复添加  因为本地图片可能不止一次上传过
                ArrayList<String> removedData = new ArrayList<>();
                for (String s : getOriginalImage()) {
                    for (String s1 : stringList) {
                        if (s1.contains(FileUtils.getFileSimpleName(s))) {
                            removedData.add(s1);
                        }
                    }
                }
                //从已上传的数据中剔除本地存在的文件 接下来会更新这部分内容  ↓↓↓
                stringList.removeAll(removedData);

                for (String s : getOriginalImage()) {
                    String s1 = FileUtils.getFileSimpleName(s) + "#" + OssManager.getOssUrl(FileUtils.getFileThumName(s)) + "#";
                    if (all) {
                        s1 = s1 + OssManager.getOssUrl(FileUtils.getFileSimpleName(s)) + "#";
                    }
                    stringList.add(s1);
                }
            }
        } else {//本地数据
            stringList.clear();//本地数据不用考虑已经上传的图片 直接清空 重新构造
            if (ListUtils.isHaveContent(getOriginalImage())) {
                for (String s : getOriginalImage()) {
                    String s1 = FileUtils.getFileSimpleName(s) + "#" + OssManager.getOssUrl(FileUtils.getFileThumName(s)) + "#";
                    if (all) {
                        s1 = s1 + OssManager.getOssUrl(FileUtils.getFileSimpleName(s)) + "#";
                    }
                    stringList.add(s1);
                }
            }
        }

        setSpecialResultData(CruiseContract.NODE_EDIT_DATA_PICTURE, stringList);
    }

    /**
     * description:将视频信息添加到任务结果中
     * 1.如果是本地任务 则直接将已上传的视频清空 重新构造
     * 2.如果是从服务器下载的任务 则：
     * (1).保留已经上传的视频
     * (2).添加本地视频
     *
     * @param all 标记是否需要添加原视频路径
     */
    public void buildVideos(boolean all, CruiseData cruiseData) {////视频格式为 uuid#缩略图路径#源文件路径
        List<String> stringList = getUploadedVideo();
        if (stringList == null) {
            stringList = new ArrayList<>();
        }
        if (cruiseData.isFromNet()) {
            if (ListUtils.isHaveContent(getOriginalVideos())) {//有数据的话保存
                //剔除掉那些已经存的内容 避免重复添加
                ArrayList<String> removedData = new ArrayList<>();
                for (String s : getOriginalVideos()) {
                    for (String s1 : stringList) {
                        if (s1.contains(FileUtils.getFileSimpleName(s))) {
                            removedData.add(s1);
                        }
                    }
                }
                stringList.removeAll(removedData);

                for (String s : getOriginalVideos()) {
                    String s1 = FileUtils.getFileSimpleName(s) + "#" + OssManager.getOssUrl(FileUtils.getVideoThumName(s)) + "#";
                    if (all) {
                        s1 = s1 + OssManager.getOssUrl(FileUtils.getFileSimpleName(s)) + "#";
                    }
                    stringList.add(s1);
                }

            }
        } else {
            stringList.clear();
            if (ListUtils.isHaveContent(getOriginalVideos())) {
                for (String s : getOriginalVideos()) {
                    String s1 = FileUtils.getFileSimpleName(s) + "#" + OssManager.getOssUrl(FileUtils.getVideoThumName(s)) + "#";
                    if (all) {
                        s1 = s1 + OssManager.getOssUrl(FileUtils.getFileSimpleName(s)) + "#";
                    }
                    stringList.add(s1);
                }
            }
        }

        setSpecialResultData(CruiseContract.NODE_EDIT_DATA_VIDEO, stringList);
    }

    /**
     * description:将语音信息添加到任务结果中
     * 1.如果是本地任务 则直接将已上传的语音清空 重新构造
     * 2.如果是从服务器下载的任务 则：
     * (1).保留已经上传的语音
     * (2).添加本地语音
     */

    public void buildAudio(CruiseData cruiseData) {////录音格式为 uuid#源文件路径
        List<String> stringList = getUploadedAudio();
        if (stringList == null) {
            stringList = new ArrayList<>();
        }
        if (cruiseData.isFromNet()) {
            if (ListUtils.isHaveContent(getOriginalAudios())) {//有数据的话保存
                //剔除掉那些已经存的内容 避免重复添加
                ArrayList<String> removedData = new ArrayList<>();
                for (String s : getOriginalAudios()) {
                    for (String s1 : stringList) {
                        if (s1.contains(FileUtils.getFileSimpleName(s))) {
                            removedData.add(s1);
                        }
                    }
                }
                stringList.removeAll(removedData);

                for (String s : getOriginalAudios()) {
                    String s1 = FileUtils.getFileSimpleName(s) + "#" + OssManager.getOssUrl(FileUtils.getFileSimpleName(s)) + "#";
                    stringList.add(s1);
                }
            }
        } else {
            stringList.clear();
            if (ListUtils.isHaveContent(getOriginalAudios())) {
                for (String s : getOriginalAudios()) {
                    String s1 = FileUtils.getFileSimpleName(s) + "#" + OssManager.getOssUrl(FileUtils.getFileSimpleName(s)) + "#";
                    stringList.add(s1);
                }
            }
        }

        setSpecialResultData(CruiseContract.NODE_EDIT_DATA_AUDIO, stringList);
    }

    /**
     * description:将指定类型的数据填充到结果里面
     *
     * @param type 数据类型 {@link CruiseContract#NODE_EDIT_DATA_VIDEO}等
     * @param data 数据列表
     */

    private void setSpecialResultData(String type, List<String> data) {
        Map<String, String> map = getResultMap();
        if (map == null) {
            map = new HashMap<>();
        }
        map.put(type, JSON.toJSON(data).toString());
        setTaskResultMap(JSON.toJSON(map).toString());
    }

    /**
     * description:构造节点概要结果信息
     */

    public void buildTaskSimpleData(CruiseData cruiseData) {
        if (isNeedText()) {
            buildText();
        }
        if (isNeedScan()) {
            buildQrCode();
        }
        if (isNeedPicture()) {
            buildImages(false, cruiseData);
        }
        if (isNeedAudio()) {
            buildAudio(cruiseData);
        }
        if (isNeedVideo()) {
            buildVideos(false, cruiseData);
        }
    }

    /**
     * description:构造节点全部结果信息
     */

    public void buildTaskAllData(CruiseData cruiseData) {
        if (isNeedText()) {
            buildText();
        }
        if (isNeedScan()) {
            buildQrCode();
        }
        if (isNeedPicture()) {
            buildImages(true, cruiseData);
        }
        if (isNeedAudio()) {
            buildAudio(cruiseData);
        }
        if (isNeedVideo()) {
            buildVideos(true, cruiseData);
        }
    }

    /**
     * description:清空数据
     */

    public void cleanData() {
        setTaskResultMap(null);
        setOriginalImage(null);
        setOriginalVideos(null);
        setOriginalAudios(null);
    }

    /**
     * description:清空本地资源
     */

    public void clearOriginalFiles() {
        setOriginalImage(null);
        setOriginalVideos(null);
        setOriginalAudios(null);
    }

    /**
     * description:检查是否含有大的本地数据
     */

    public boolean isHaveBigLocalFile() {
        return ListUtils.isHaveContent(getOriginalImage()) || ListUtils.isHaveContent(getOriginalVideos());
    }

    /**
     * description:检查内容是否齐全
     */

    public boolean checkContent(CruiseData cruiseData) {
        if (isNeedText()) {
            if (TextUtils.isEmpty(getText())) {
                return false;
            }
        }
        if (isNeedScan()) {
            if (TextUtils.isEmpty(getQrCode())) {
                return false;
            }
        }
        if (isNeedPicture()) {
            if (!ListUtils.isHaveContent(getShowImage(cruiseData))) {
                return false;
            }
        }
        if (isNeedVideo()) {
            if (!ListUtils.isHaveContent(getShowVideo(cruiseData))) {
                return false;
            }
        }
        if (isNeedAudio()) {
            if (!ListUtils.isHaveContent(getShowAudio(cruiseData))) {
                return false;
            }
        }
        return true;
    }

}